package com.ictest.detectionflow.mobile;

import java.io.File;
import java.io.InputStreamReader;
import java.util.ArrayList;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.protocol.HTTP;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import android.app.Activity;
import android.app.AlertDialog;
import android.app.ProgressDialog;
import android.content.ActivityNotFoundException;
import android.content.ContentValues;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.graphics.Bitmap;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Environment;
import android.provider.MediaStore;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.AdapterView.OnItemLongClickListener;
import android.widget.AutoCompleteTextView;
import android.widget.BaseAdapter;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Filter;
import android.widget.Filterable;
import android.widget.Gallery;
import android.widget.ImageButton;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;

import com.ictest.detectionflow.mobile.model.Customer;
import com.ictest.detectionflow.mobile.model.Manifest;
import com.ictest.detectionflow.mobile.model.ManifestPhoto;

/**
 * 创建清单活动。
 * 
 * @author ZengE
 * 
 */
public class ManifestActivity extends Activity
{
	/**
	 * 日志标记。
	 */
	private final static String LOG_TAG = "ManifestActivity";

	/**
	 * 图片文件序号。
	 */
	private int m_PictureIndex;

	/**
	 * 当前图片文件。
	 */
	private File m_CurrentImageFile;

	/**
	 * 相机活动编号。
	 */
	private final static int CODE_CAMERA = 100;

	/**
	 * 相册活动编号。
	 */
	private final static int CODE_GALLERY = 200;

	/**
	 * 预览活动编号。
	 */
	private final static int CODE_PREVIEW = 300;

	/**
	 * 图片过滤。
	 */
	public static final String IMAGE_UNSPECIFIED = "image/*";

	/**
	 * 图片集合控件。
	 */
	private Gallery m_Gallery;

	/**
	 * 数据库操作辅助对象。
	 */
	private DatabaseHelper m_Helper;

	/**
	 * 图片适配器。
	 */
	private PhotoAdapter m_PhotoAdapter;

	/**
	 * 当前清单对象。
	 */
	private final Manifest m_CurrentManifest = new Manifest();

	/**
	 * 客户信息输入控件。
	 */
	private AutoCompleteTextView txtCustomer;

	/**
	 * 客户信息适配器。
	 */
	private CustomerListAdapter m_CustomerAdapter;

	@Override
	public void onCreate(Bundle savedInstanceState)
	{
		// 调用基类实现
		super.onCreate(savedInstanceState);
		// 设置内容视图
		setContentView(R.layout.activity_manifest);

		// 创建数据库辅助对象
		this.m_Helper = new DatabaseHelper(ManifestActivity.this);

		// 设置图片编号
		this.m_PictureIndex = 0;

		// 获得返回按钮
		ImageButton cmdBack = (ImageButton) this.findViewById(R.id.cmdBack);

		// 挂接点击事件监听
		cmdBack.setOnClickListener(new View.OnClickListener()
		{
			// 处理点击事件
			public void onClick(View v)
			{
				// 结束页面
				ManifestActivity.this.finish();
			}
		});

		// 获得确定按钮
		Button cmdOK = (Button) this.findViewById(R.id.cmdOK);

		// 挂接点击事件
		cmdOK.setOnClickListener(new OnClickListener()
		{
			// 处理点击事件
			public void onClick(View v)
			{
				// 判断是否指定了客户编号
				if (Utility.IsNullOrEmpty(ManifestActivity.this.m_CurrentManifest.getCustomerID()))
				{
					// 设置焦点
					ManifestActivity.this.txtCustomer.requestFocus();

					// 全部选中
					ManifestActivity.this.txtCustomer.selectAll();

					// 提示信息
					Toast.makeText(ManifestActivity.this, "委托单位不能缺省，请填写委托单位。", Toast.LENGTH_SHORT).show();

					// 返回
					return;
				}

				// 获得清单说明
				EditText txtTitle = (EditText) ManifestActivity.this.findViewById(R.id.txtTitle);

				// 设置清单说明
				ManifestActivity.this.m_CurrentManifest.setTitle(txtTitle.getText().toString());

				// 判断是否指定了清单说明
				if (Utility.IsNullOrEmpty(ManifestActivity.this.m_CurrentManifest.getTitle()))
				{
					// 设置焦点
					txtTitle.requestFocus();

					// 全部选中
					txtTitle.selectAll();

					// 提示信息
					Toast.makeText(ManifestActivity.this, "清单说明不能缺省，请填写清单说明。", Toast.LENGTH_SHORT).show();

					// 返回
					return;
				}

				// 判断是否指定了照片
				if (ManifestActivity.this.getPhotos().size() == 0)
				{
					// 提示信息
					Toast.makeText(ManifestActivity.this, "清单照片不能缺省，请指定清单照片。", Toast.LENGTH_SHORT).show();

					// 返回
					return;
				}

				// 获得清单说明
				EditText txtMemo = (EditText) ManifestActivity.this.findViewById(R.id.txtMemo);

				// 设置清单说明
				ManifestActivity.this.m_CurrentManifest.setMemo(txtMemo.getText().toString());

				// 执行创建
				ManifestActivity.this.doCreate();
			}
		});

		// 获得确定按钮
		Button cmdCancel = (Button) this.findViewById(R.id.cmdCancel);

		// 挂接点击事件
		cmdCancel.setOnClickListener(new OnClickListener()
		{
			// 处理点击事件
			public void onClick(View v)
			{
				// 设定返回值
				ManifestActivity.this.setResult(Activity.RESULT_CANCELED);

				// 结束活动
				ManifestActivity.this.finish();
			}
		});

		// 获得同步按钮
		ImageButton cmdSync = (ImageButton) this.findViewById(R.id.cmdSync);

		// 挂接点击事件监听
		cmdSync.setOnClickListener(new View.OnClickListener()
		{
			// 处理点击事件
			public void onClick(View v)
			{
				// 执行数据同步
				ManifestActivity.this.doSync();
			}
		});

		// 获得图片集
		this.m_Gallery = (Gallery) this.findViewById(R.id.galManifest);

		// 创建适配器
		this.m_PhotoAdapter = new PhotoAdapter();

		// 设置适配器
		this.m_Gallery.setAdapter(this.m_PhotoAdapter);

		// 挂接长按事件
		this.m_Gallery.setOnItemLongClickListener(new OnItemLongClickListener()
		{
			public boolean onItemLongClick(AdapterView<?> adapter, View view, int position, long row)
			{
				// 获得照片信息
				ManifestPhoto photo = ManifestActivity.this.getPhotos().get(position);

				// 创建参数
				Bundle extras = new Bundle();

				// 添加参数值
				extras.putBoolean(PictureViewActivity.KEY_TEMP, false);
				extras.putSerializable(PictureViewActivity.KEY_PATH, photo.getImageFile());
				extras.putString(PictureViewActivity.KEY_NAME, photo.getName());
				extras.putInt(PictureViewActivity.KEY_INDEX, position);
				extras.putBoolean(PictureViewActivity.KEY_ISPREVIEW, true);

				// 启动活动
				Utility.startActivityForResult(ManifestActivity.this, PictureViewActivity.class, extras, CODE_PREVIEW);

				// 返回处理
				return true;
			}
		});

		// 获得照片按钮
		ImageButton cmdPhoto = (ImageButton) this.findViewById(R.id.cmdPhoto);

		// 挂接点击事件
		cmdPhoto.setOnClickListener(new OnClickListener()
		{
			// 处理点击事件
			public void onClick(View v)
			{
				// 创建对话框构建器
				AlertDialog.Builder dialog = new AlertDialog.Builder(ManifestActivity.this);

				// 设置标题
				dialog.setTitle(R.string.title_dialog_selectimage);
				// 设置选项
				dialog.setItems(R.array.items_image_source, new DialogInterface.OnClickListener()
				{

					public void onClick(DialogInterface dialog, int which)
					{
						// 判断是否相机拍摄
						if (which == 0)
						{
							// 拍摄照片
							ManifestActivity.this.takePicture();
						}
						else
						{
							// 选择照片
							ManifestActivity.this.pickPicture();
						}
					}
				});

				// 显示对话框
				dialog.show();
			}
		});

		// 获得客户名输入控件
		this.txtCustomer = (AutoCompleteTextView) this.findViewById(R.id.txtCustomer);

		// 挂接事件
		this.txtCustomer.setOnItemClickListener(new OnItemClickListener()
		{
			public void onItemClick(AdapterView<?> adapter, View view, int position, long row)
			{
				// 获得选中的项目
				Customer entity = (Customer) adapter.getItemAtPosition(position);

				// 判断是否选中
				if (null != entity)
				{
					// 设置客户编号
					ManifestActivity.this.m_CurrentManifest.setCustomerID(entity.getID());
				}
				else
				{
					// 设置客户编号
					ManifestActivity.this.m_CurrentManifest.setCustomerID(null);
				}
			}
		});

		// 创建客户信息适配器
		this.m_CustomerAdapter = new CustomerListAdapter();

		// 设置适配器
		this.txtCustomer.setAdapter(this.m_CustomerAdapter);
	}

	@Override
	public boolean onCreateOptionsMenu(Menu menu)
	{
		try
		{
			// 获得菜单对象
			getMenuInflater().inflate(R.menu.activity_manifest, menu);

			// 返回成功
			return true;
		}
		catch (Exception ex)
		{
			// 记录日志
			Log.e(LOG_TAG, "加载菜单的过程中发生错误。\r\n" + ex.toString());

			// 返回失败
			return false;
		}
	}

	@Override
	public boolean onOptionsItemSelected(MenuItem item)
	{
		// 根据选中的菜单项目进行处理
		switch (item.getItemId())
		{
		case R.id.menu_setting:
			// 导航到设定页面
			Utility.startActivity(ManifestActivity.this, SettingActivity.class, null);
			// 终止
			break;
		case R.id.menu_sync:
			// 执行数据同步
			ManifestActivity.this.doSync();
			// 终止
			break;
		}

		// 返回成功
		return true;
	}

	/**
	 * 获得所有需要上传的照片。
	 * 
	 * @return 照片列表。
	 */
	public ArrayList<ManifestPhoto> getPhotos()
	{
		return this.m_PhotoAdapter.getPhotos();
	}

	@Override
	protected void onDestroy()
	{
		// 调用基类实现
		super.onDestroy();

		// 清除适配器
		this.m_PhotoAdapter.close();

		// 清除客户信息适配器
		this.m_CustomerAdapter.close();
	}

	@Override
	protected void onActivityResult(int requestCode, int resultCode, Intent data)
	{
		// 调用基类实现
		super.onActivityResult(requestCode, resultCode, data);

		// 判断是否成功
		if (resultCode == Activity.RESULT_CANCELED)
		{
			// 判断是否预览
			if (requestCode == CODE_PREVIEW && null != data)
			{
				// 获得索引位置
				int position = data.getIntExtra(PictureViewActivity.KEY_INDEX, -1);

				// 判断是否指定了序号
				if (position >= 0)
				{
					// 获得照片对象
					ManifestPhoto photo = ManifestActivity.this.getPhotos().get(position);

					// 从列表中删除
					ManifestActivity.this.getPhotos().remove(position);

					// 释放图片
					if (null != photo.getPhoto())
					{
						photo.getPhoto().recycle();
					}

					// 判断是否为临时文件
					if (photo.getIsTempFile())
					{
						try
						{
							// 删除文件
							photo.getImageFile().delete();
						}
						catch (Exception ex)
						{
							Log.e(LOG_TAG, ex.toString());
						}
					}

					// 通知数据发生变化
					ManifestActivity.this.m_PhotoAdapter.notifyDataSetChanged();
				}
			}

			// 如果没有成功，则直接返回
			return;
		}

		// 用于记录是否为临时文件
		boolean isTempFile = true;

		// 判断是否从相册中选择
		if (requestCode == CODE_GALLERY)
		{
			// 设置为不是临时文件
			isTempFile = false;

			// 获得文件地址
			Uri imageUrl = data.getData();

			// 获得图片文件路径
			String imageFilePath = Utility.getFilePathFromURI(this, imageUrl);

			// 创建文件对象
			this.m_CurrentImageFile = new File(imageFilePath);
		}

		// 判断是否为相册活动
		if (requestCode == CODE_CAMERA || requestCode == CODE_GALLERY)
		{
			// 创建参数
			Bundle extras = new Bundle();

			// 增加图片编号
			this.m_PictureIndex += 1;

			// 添加参数值
			extras.putBoolean(PictureViewActivity.KEY_TEMP, isTempFile);
			extras.putBoolean(PictureViewActivity.KEY_ISPREVIEW, false);
			extras.putSerializable(PictureViewActivity.KEY_PATH, this.m_CurrentImageFile);
			extras.putString(PictureViewActivity.KEY_NAME, String.format("%1$02d", this.m_PictureIndex));

			// 启动活动
			Utility.startActivityForResult(ManifestActivity.this, PictureViewActivity.class, extras, CODE_PREVIEW);
		}
		else if (requestCode == CODE_PREVIEW)
		{
			// 判断是否预览
			if (data.getBooleanExtra(PictureViewActivity.KEY_ISPREVIEW, false))
			{
				// 获得索引位置
				int position = data.getIntExtra(PictureViewActivity.KEY_INDEX, -1);

				// 判断是否指定了序号
				if (position >= 0)
				{
					// 获得照片对象
					ManifestPhoto photo = ManifestActivity.this.getPhotos().get(position);

					// 获得图片名称
					String imageName = data.getStringExtra(PictureViewActivity.KEY_NAME);

					// 设置图片名称
					photo.setName(imageName);

					// 通知数据发生变化
					ManifestActivity.this.m_PhotoAdapter.notifyDataSetChanged();
				}
			}
			else
			{
				// 获得图片路径
				File imageFile = (File) data.getSerializableExtra(PictureViewActivity.KEY_PATH);

				// 获得图片名称
				String imageName = data.getStringExtra(PictureViewActivity.KEY_NAME);

				// 是否为临时文件
				isTempFile = data.getBooleanExtra(PictureViewActivity.KEY_TEMP, false);

				// 创建图片
				Bitmap picture = Utility.getBitmapFromFile(imageFile, 64, 64);

				// 判断是否创建成功
				if (null != picture)
				{
					// 创建实体
					ManifestPhoto entity = new ManifestPhoto();

					// 设置属性
					entity.setName(imageName);
					entity.setPhoto(picture);
					entity.setImageFile(imageFile);
					entity.setIsTempFile(isTempFile);

					// 添加照片
					int position = this.m_PhotoAdapter.appendPhoto(entity);

					// 选中图片
					this.m_Gallery.setSelection(position);
				}
			}
		}
	}

	/**
	 * 拍摄照片。
	 */
	private void takePicture()
	{
		// 创建意图
		Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);

		// 生成照片文件路径
		String tempFilePath = Environment.getExternalStorageDirectory() + File.separator + String.format("manifest_picture%1$d.jpg", System.currentTimeMillis());

		// 创建文件对象
		this.m_CurrentImageFile = new File(tempFilePath);

		// 设置照片文件名称
		intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(this.m_CurrentImageFile));

		try
		{
			// 启动活动
			startActivityForResult(intent, CODE_CAMERA);
		}
		catch (ActivityNotFoundException ex)
		{
			// 记录日志
			Log.e(LOG_TAG, "本机不支持拍摄照片。\r\n" + ex.toString());

			// 提示错误
			Toast.makeText(this, "本机不支持拍摄照片。", Toast.LENGTH_LONG).show();
		}
	}

	/**
	 * 选择照片。
	 */
	private void pickPicture()
	{
		// 创建意图
		Intent intent = new Intent(Intent.ACTION_GET_CONTENT, null);

		// 设置参数
		intent.setDataAndType(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, IMAGE_UNSPECIFIED);

		try
		{
			// 启动活动
			startActivityForResult(intent, CODE_GALLERY);
		}
		catch (ActivityNotFoundException ex)
		{
			// 记录日志
			Log.e(LOG_TAG, "没有找到照片。\r\n" + ex.toString());

			// 提示错误
			Toast.makeText(this, "没有找到照片。", Toast.LENGTH_LONG).show();
		}
	}

	/**
	 * 执行数据同步。
	 */
	private void doSync()
	{
		// 判断是否登录
		if (Utility.IsNullOrEmpty(LoginActivity.SESSION_ID))
		{
			// 提示信息
			Utility.notifyLogin(ManifestActivity.this);

			// 返回
			return;
		}
		// 判断是否设定了服务器地址
		else if (!Utility.hasServiceAddress(this))
		{
			// 提示消息
			Utility.notifySetServiceAddress(this);
		}
		else
		{
			// 创建同步任务
			ManifestActivity.SyncTask task = new ManifestActivity.SyncTask(this, this.getDatabaseHelper());

			// 启用同步任务
			task.execute();
		}
	}

	/**
	 * 执行创建任务。
	 */
	private void doCreate()
	{
		// 判断是否登录
		if (Utility.IsNullOrEmpty(LoginActivity.SESSION_ID))
		{
			// 提示信息
			Utility.notifyLogin(ManifestActivity.this);

			// 返回
			return;
		}
		// 判断是否设定了服务器地址
		else if (!Utility.hasServiceAddress(this))
		{
			// 提示消息
			Utility.notifySetServiceAddress(this);
		}
		else
		{
			// 创建同步任务
			ManifestActivity.CreateTask task = new ManifestActivity.CreateTask();

			// 启用同步任务
			task.execute(this.m_CurrentManifest);
		}
	}

	/**
	 * 获得数据库操作辅助对象。
	 */
	public DatabaseHelper getDatabaseHelper()
	{
		// 返回数据库操作辅助对象。
		return this.m_Helper;
	}

	/**
	 * 清单照片适配器。
	 */
	private class PhotoAdapter extends BaseAdapter
	{
		/**
		 * 布局对象。
		 */
		private final LayoutInflater m_Inflater;

		/**
		 * 图片列表。
		 */
		private final ArrayList<ManifestPhoto> m_Pictures = new ArrayList<ManifestPhoto>();

		/**
		 * 构造函数。
		 */
		public PhotoAdapter()
		{
			// 获得布局对象
			this.m_Inflater = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
		}

		/**
		 * 获得记录的总数。
		 */
		public int getCount()
		{
			// 返回记录总数
			return this.m_Pictures.size();
		}

		/**
		 * 获得指定位置的数据对象。
		 */
		public Object getItem(int position)
		{
			return this.m_Pictures.get(position);
		}

		/**
		 * 获得指定位置的数据对象的编号。
		 */
		public long getItemId(int position)
		{
			// 默认返回位置
			return position;
		}

		/**
		 * 获得指定位置元素的显示视图。
		 */
		public View getView(int position, View convertView, ViewGroup parent)
		{
			// 判断视图是否创建
			if (null == convertView)
			{
				// 创建项目视图
				convertView = this.m_Inflater.inflate(R.layout.manifest_gallery_item, null);
			}

			// 获得图片控件
			ImageView imgThumb = (ImageView) convertView.findViewById(R.id.imgThumb);

			// 获得实体
			ManifestPhoto entity = (ManifestPhoto) this.getItem(position);

			// 设置图片
			imgThumb.setImageBitmap(entity.getPhoto());

			// 获得文字
			TextView txtName = (TextView) convertView.findViewById(R.id.txtName);

			// 设置名称
			txtName.setText(entity.getName());

			// 返回视图
			return convertView;
		}

		/**
		 * 添加照片。
		 * 
		 * @param photo
		 *            要添加的照片。
		 * @return 添加图片的索引位置。
		 */
		public int appendPhoto(ManifestPhoto photo)
		{
			// 添加照片
			this.m_Pictures.add(photo);

			// 通知发生变化
			this.notifyDataSetChanged();

			// 返回总数
			return this.m_Pictures.size() - 1;
		}

		/**
		 * 关闭适配器。
		 */
		public void close()
		{
			// 循环处理文件
			for (ManifestPhoto photo : this.m_Pictures)
			{
				// 释放图片
				if (null != photo.getPhoto())
				{
					photo.getPhoto().recycle();
				}

				// 判断是否为临时文件
				if (photo.getIsTempFile())
				{
					try
					{
						// 删除文件
						photo.getImageFile().delete();
					}
					catch (Exception ex)
					{
						Log.e(LOG_TAG, ex.toString());
					}
				}

			}

			// 清除集合
			this.m_Pictures.clear();
		}

		/**
		 * 获得所有需要上传的照片。
		 * 
		 * @return 照片列表。
		 */
		public ArrayList<ManifestPhoto> getPhotos()
		{
			return this.m_Pictures;
		}
	}

	/**
	 * 客户信息适配器。
	 */
	private class CustomerListAdapter extends BaseAdapter implements Filterable
	{
		/**
		 * 日志标记。
		 */
		private final static String LOG_TAG = "CustomerListAdapter";

		/**
		 * 用于记录数据的总数。
		 */
		private int m_Count;

		/**
		 * 数据库游标。
		 */
		private Cursor m_Cursor;

		/**
		 * 数据库对象。
		 */
		private SQLiteDatabase m_Database;

		/**
		 * 布局对象。
		 */
		private final LayoutInflater m_Inflater;

		/**
		 * 客户信息过滤器。
		 */
		private CustomerFilter m_Filter;

		/**
		 * 构造函数。
		 */
		public CustomerListAdapter()
		{
			// 获得布局对象
			this.m_Inflater = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
		}

		/**
		 * 获得记录的总数。
		 */
		public int getCount()
		{
			// 返回记录总数
			return this.m_Count;
		}

		/**
		 * 获得指定位置的数据对象。
		 */
		public Object getItem(int position)
		{
			// 判断是否设置了游标
			if (null == this.m_Cursor)
			{
				// 返回空引用
				return null;
			}
			else
			{
				// 移动到指定数据行
				this.m_Cursor.moveToPosition(position);

				// 创建对象
				Customer entity = new Customer();

				// 设置属性
				entity.setID(this.m_Cursor.getString(0));
				entity.setName(this.m_Cursor.getString(1));
				entity.setShortName(this.m_Cursor.getString(2));

				// 返回实体
				return entity;
			}
		}

		/**
		 * 获得指定位置的数据对象的编号。
		 */
		public long getItemId(int position)
		{
			// 默认返回位置
			return position;
		}

		/**
		 * 获得指定位置元素的显示视图。
		 */
		public View getView(int position, View convertView, ViewGroup parent)
		{
			// 判断视图是否创建
			if (null == convertView)
			{
				// 创建项目视图
				convertView = this.m_Inflater.inflate(R.layout.listitem_customer, null);
			}

			// 判断游标是否有效
			if (null != this.m_Cursor)
			{
				// 移动到当前数据行
				this.m_Cursor.moveToPosition(position);

				// 获得名称控件
				TextView txtName = (TextView) convertView.findViewById(R.id.txtName);

				// 设置名称
				txtName.setText(this.m_Cursor.getString(1));
			}

			// 返回视图
			return convertView;
		}

		/**
		 * 查询数据。
		 * 
		 * @param condition
		 *            查询条件。
		 * @throws InterruptedException
		 */
		public void doQuery(String condition)
		{
			// 判断数据库对象是否已经创建
			if (null == this.m_Database)
			{
				// 获得数据库对象
				this.m_Database = ManifestActivity.this.getDatabaseHelper().getReadableDatabase();
			}

			// 判断游标是否已经创建
			if (null != this.m_Cursor)
			{
				// 关闭游标
				this.m_Cursor.close();

				// 清除游标
				this.m_Cursor = null;
			}

			// 获得总数查询字符串
			String queryCount = ManifestActivity.this.getString(R.string.sql_query_customer_count);

			// 获得查询字符串
			String query = ManifestActivity.this.getString(R.string.sql_query_customer);

			// 创建过滤条件
			String filter = String.format("WHERE ShortName LIKE '%1$s%%'", condition);

			// 设置过滤条件
			query = String.format(query, filter);

			// 设置过滤条件
			queryCount = String.format(queryCount, filter);

			// 清除游标
			this.m_Cursor = null;

			try
			{
				// 查询总记录数
				this.m_Count = Utility.querySingleInteger(this.m_Database, queryCount);

				// 判断是否有数据
				if (this.m_Count > 0)
				{
					// 查询数据
					this.m_Cursor = this.m_Database.rawQuery(query, null);
				}
			}
			catch (Exception ex)
			{
				// 输出日志
				Log.e(LOG_TAG, ex.toString());

				// 设置记录数为0，表示查询出错
				this.m_Count = 0;

				// 判断游标是否已经创建
				if (null != this.m_Cursor)
				{
					// 关闭游标
					this.m_Cursor.close();

					// 清除游标
					this.m_Cursor = null;
				}
			}
		}

		/**
		 * 关闭适配器。
		 */
		public void close()
		{
			// 判断当前游标是否存在
			if (this.m_Cursor != null)
			{
				// 关闭游标
				this.m_Cursor.close();

				// 清除游标
				this.m_Cursor = null;
			}

			// 判断当前数据库是否存在
			if (this.m_Database != null)
			{
				// 关闭游标
				this.m_Database.close();

				// 清除游标
				this.m_Database = null;
			}
		}

		public Filter getFilter()
		{
			// 判断客户信息过滤器是否已经创建
			if (null == this.m_Filter)
			{
				// 创建过滤器
				this.m_Filter = new CustomerFilter();
			}

			// 返回过滤器
			return this.m_Filter;
		}

		/**
		 * 客户信息过滤器。
		 * 
		 * @author zanezeng
		 * 
		 */
		private class CustomerFilter extends Filter
		{
			/**
			 * 过滤结果。
			 */
			private final FilterResults m_Results = new FilterResults();

			@Override
			protected FilterResults performFiltering(CharSequence constraint)
			{
				// 执行查询
				CustomerListAdapter.this.doQuery(constraint.toString());

				// 清除客户编号
				ManifestActivity.this.m_CurrentManifest.setCustomerID(null);

				// 设置记录总数
				this.m_Results.count = CustomerListAdapter.this.m_Count;

				// 返回结果
				return this.m_Results;
			}

			@Override
			protected void publishResults(CharSequence constraint, FilterResults results)
			{
				// 判断是否有记录
				if (results != null && results.count > 0)
				{
					// 通知数据发生变化
					CustomerListAdapter.this.notifyDataSetChanged();
				}
				else
				{
					// 通知数据无效
					CustomerListAdapter.this.notifyDataSetInvalidated();
				}
			}

		}
	}

	/**
	 * 同步任务对象。
	 */
	public static class SyncTask extends AsyncTask<String, String, Integer>
	{
		/**
		 * 进度对话框。
		 */
		private ProgressDialog m_ProgressDialog;

		/**
		 * 同步的过程中发生的错误。
		 */
		private Exception m_SyncException;

		/**
		 * 数据读取缓存长度。
		 */
		private final static int BUFFER_LENGTH = 1024;

		/**
		 * HTTP请求成功编码。
		 */
		private final static int HTTP_OK = 200;

		/**
		 * 连接超时。
		 */
		private final static int CONNECTION_TIMEOUT = 10000;

		/**
		 * 数据接收超时。
		 */
		private final static int SOCKET_TIMEOUT = 30000;

		/**
		 * 日志标记。
		 */
		private final static String LOG_TAG = "SyncTask";

		/**
		 * 上下文对象。
		 */
		private final Activity m_Context;

		/**
		 * 数据库操作辅助对象。
		 */
		private final DatabaseHelper m_Helper;

		/**
		 * 是否自行管理辅助对象。
		 */
		private final boolean m_IsOwnHelper;

		/**
		 * @param context
		 *            上下文对象。
		 */
		public SyncTask(Activity context, DatabaseHelper helper)
		{
			// 保存上下文
			this.m_Context = context;

			// 判断是否指定了辅助类
			if (null == helper)
			{
				// 创建辅助对象
				this.m_Helper = new DatabaseHelper(context);

				// 设置自行管理
				this.m_IsOwnHelper = true;
			}
			else
			{
				// 保存数据库操作辅助对象
				this.m_Helper = helper;

				// 设置非自行管理
				this.m_IsOwnHelper = false;
			}
		}

		@Override
		protected void onPreExecute()
		{
			// 创建进度对话框
			this.m_ProgressDialog = new ProgressDialog(this.m_Context);
			// 设置进度条样式
			this.m_ProgressDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
			// 设置标题
			this.m_ProgressDialog.setTitle(R.string.title_sync_customer);
			// 设置提示信息
			this.m_ProgressDialog.setMessage(this.m_Context.getString(R.string.message_sync));
			// 设置允许取消
			this.m_ProgressDialog.setCancelable(true);
			// 挂接后退按钮点击事件
			this.m_ProgressDialog.setOnCancelListener(new DialogInterface.OnCancelListener()
			{
				// 处理取消按钮点击事件
				public void onCancel(DialogInterface dialog)
				{
					// 取消任务
					SyncTask.this.cancel(true);
				}
			});
			// 设置按钮标题
			this.m_ProgressDialog.setButton(this.m_Context.getString(R.string.button_cancel), new DialogInterface.OnClickListener()
			{
				public void onClick(DialogInterface dialog, int which)
				{
					// 取消任务
					SyncTask.this.cancel(true);
				}
			});

			// 设置图标
			this.m_ProgressDialog.setIcon(R.drawable.icon_sync);
			// 显示对话框
			this.m_ProgressDialog.show();
		}

		@Override
		protected Integer doInBackground(String... params)
		{
			// 用于保存数据库连接
			SQLiteDatabase database = null;

			try
			{
				// 用于记录同步数据的总数
				int totalRecords = 0;

				// 创建请求客户端
				DefaultHttpClient client = new DefaultHttpClient();

				// 进度通知
				this.publishProgress("开始查询客户数据的版本信息");

				// 获得可写数据库对象
				database = this.m_Helper.getWritableDatabase();

				// 获得最后同步的数据版本号
				String latestVersion = this.RetrieveLatestVersion(database);

				// 进度通知
				this.publishProgress("完成查询客户数据的版本信息");

				// 进度通知
				this.publishProgress("开始同步客户数据");

				// 循环同步数据
				while (true)
				{
					// 查询数据
					JSONArray data = this.RetrieveData(client, latestVersion);

					// 用于保存记录信息
					ContentValues record = new ContentValues();

					// 循环插入到数据库
					for (int index = 0; index < data.length(); index++)
					{
						// 获得单个客户数据
						JSONObject source = data.getJSONObject(index);

						// 组装记录信息
						this.AssemContentValues(source, record);

						// 删除重复记录
						database.delete("Customer", "ID=?", new String[] { record.getAsString("ID") });

						// 插入记录
						database.insert("Customer", null, record);

						// 设置最后同步的版本信息
						latestVersion = record.getAsString("Version");

						// 记录已经同步的记录数据
						totalRecords += 1;

						// 进度通知
						this.publishProgress(String.format("%1$d条客户数据被同步", totalRecords));
					}

					// 判断是否需要继续同步
					if (data.length() < 100)
					{
						// 判断是否同步了数据
						if (totalRecords == 0)
						{
							// 进度通知
							this.publishProgress("没有发现需要同步的客户数据");
						}

						// 进度通知
						this.publishProgress("结束同步客户数据");

						// 退出同步
						break;
					}
				}

				// 返回同步成功
				return totalRecords;
			}
			catch (Exception ex)
			{
				// 记录日志
				Log.e(SyncTask.LOG_TAG, ex.toString());

				// 记录同步过程中发生的异常
				this.m_SyncException = ex;

				// 返回同步失败
				return -1;
			}
			finally
			{
				// 关闭数据库连接
				if (null != database)
				{
					database.close();
				}

				// 判断是否自行管理辅助类
				if (this.m_IsOwnHelper)
				{
					// 关闭辅助对象
					this.m_Helper.close();
				}
			}
		}

		@Override
		protected void onProgressUpdate(String... values)
		{
			// 判断进度窗体是否已经创建
			if (null != this.m_ProgressDialog)
			{
				this.m_ProgressDialog.setMessage(values[0]);
			}
		}

		/**
		 * 同步任务后置处理器。
		 */
		@Override
		protected void onPostExecute(Integer result)
		{
			// 释放对话框对象
			if (null != this.m_ProgressDialog)
			{
				this.m_ProgressDialog.dismiss();
			}

			// 判断是否同步成功
			if (result == 0)
			{
				// 提示完成
				Toast.makeText(this.m_Context, "同步完成，没有发现需要同步的客户数据", Toast.LENGTH_SHORT).show();
			}
			else if (result > 0)
			{
				// 提示完成
				Toast.makeText(this.m_Context, String.format("同步完成，%1$d条客户数据被同步", result), Toast.LENGTH_SHORT).show();
			}
			else if (null != this.m_SyncException)
			{
				// 创建对话框
				AlertDialog.Builder dialog = new AlertDialog.Builder(this.m_Context);

				// 设置标题
				dialog.setTitle(R.string.title_application_name);
				// 设置消息
				dialog.setMessage("同步失败，数据同步的过程中发生错误：\r\n" + this.m_SyncException.toString());
				// 设置不允许取消
				dialog.setCancelable(false);
				// 设置图标编号
				dialog.setIcon(R.drawable.icon_error);

				// 添加取消按钮
				dialog.setPositiveButton(R.string.button_ok, new AlertDialog.OnClickListener()
				{
					// 处理点击事件
					public void onClick(DialogInterface dialog, int which)
					{
						// 关闭对话框
						dialog.dismiss();
					}
				});

				// 显示对话框
				dialog.show();
			}
		}

		/**
		 * 获得同步的最晚数据版本。
		 */
		private String RetrieveLatestVersion(SQLiteDatabase database)
		{
			// 获得查询语句
			String query = this.m_Context.getResources().getString(R.string.sql_query_customer_max_version);

			// 用于保存版本号
			Long latestVersion = Utility.querySingleLong(database, query);

			// 判断是否有数据
			if (null == latestVersion)
			{
				// 默认为0
				latestVersion = 0L;
			}

			// 返回版本号
			return Long.toString(latestVersion);
		}

		/**
		 * 从服务端获得客户数据。
		 */
		private JSONArray RetrieveData(DefaultHttpClient client, String version) throws Exception
		{
			// 获得共享存储器
			SharedPreferences settings = this.m_Context.getSharedPreferences(this.m_Context.getString(R.string.app_name), 0);

			// 读取服务器地址
			String serverAddress = settings.getString(SettingActivity.KEY_ADDRESS, null);

			// 判断是否以/结尾
			if (serverAddress.endsWith("/"))
			{
				serverAddress = String.format("%1$sServices/MobileService.svc/GetCustomerInfo/", serverAddress);
			}
			else
			{
				serverAddress = String.format("%1$s/Services/MobileService.svc/GetCustomerInfo/", serverAddress);
			}

			// 获得服务端地址
			String url = serverAddress + version;

			// 创建HTTP请求对象
			HttpGet request = new HttpGet(url);

			// 获得请求参数
			HttpParams params = request.getParams();

			// 设置连接超时
			HttpConnectionParams.setConnectionTimeout(params, SyncTask.CONNECTION_TIMEOUT);
			// 设置接收超时
			HttpConnectionParams.setSoTimeout(params, SOCKET_TIMEOUT);

			// 执行请求
			HttpResponse response = client.execute(request);

			// 读取反馈内容
			String responseText = RetrieveInputStream(response.getEntity());

			// 判断是否请求成功
			if (SyncTask.HTTP_OK != response.getStatusLine().getStatusCode())
			{
				// 记录日志
				Log.e(SyncTask.LOG_TAG, responseText);

				// 抛出异常
				throw new Exception(responseText);
			}

			// 返回数据
			return new JSONArray(responseText);
		}

		/**
		 * 从给定的HTTP实体中获得反馈内容。
		 */
		private String RetrieveInputStream(HttpEntity entity) throws Exception
		{
			// 获得内容长度
			int length = (int) entity.getContentLength();

			// 判断长度是否小于0
			if (length < 0)
			{
				// 如果小于0，则默认为10K
				length = 10 * SyncTask.BUFFER_LENGTH;
			}

			// 用于保存返回字符串内容
			StringBuffer result = new StringBuffer(length);

			// 创建输入流读取器
			InputStreamReader reader = new InputStreamReader(entity.getContent(), HTTP.UTF_8);

			// 用于保存缓存数据
			char buffer[] = new char[SyncTask.BUFFER_LENGTH];

			// 用于记录读取的数据长度
			int count = 0;

			// 循环读取数据
			do
			{
				// 读取数据
				count = reader.read(buffer, 0, SyncTask.BUFFER_LENGTH);

				// 判断是否读取了数据
				if (count > 0)
				{
					// 添加数据
					result.append(buffer, 0, count);
				}
			}
			while (count > 0);

			// 返回结果
			return result.toString();
		}

		/**
		 * 根据给定的JSON对象组装元器件信息记录对象。
		 */
		private void AssemContentValues(JSONObject source, ContentValues record) throws JSONException
		{
			// 清除内容
			record.clear();

			// 设置版本
			if (!source.isNull("Version"))
			{
				record.put("Version", source.getString("Version"));
			}

			// 设置编号
			if (!source.isNull("ID"))
			{
				record.put("ID", source.getString("ID"));
			}

			// 设置名称
			if (!source.isNull("Name"))
			{
				record.put("Name", source.getString("Name"));
			}

			// 设置生产厂商
			if (!source.isNull("ShortName"))
			{
				record.put("ShortName", source.getString("ShortName"));
			}
		}
	}

	/**
	 * 创建任务。
	 * 
	 * @author zanezeng
	 * 
	 */
	public class CreateTask extends AsyncTask<Manifest, String, JSONObject>
	{
		/**
		 * 进度对话框。
		 */
		private ProgressDialog m_ProgressDialog;

		/**
		 * 登陆过程中发生的错误。
		 */
		private Exception m_InnerException;

		/**
		 * HTTP请求成功编码。
		 */
		private final static int HTTP_OK = 200;

		/**
		 * 连接超时。
		 */
		private final static int CONNECTION_TIMEOUT = 10000;

		/**
		 * 数据接收超时。
		 */
		private final static int SOCKET_TIMEOUT = 30000;

		/**
		 * 数据读取缓存长度。
		 */
		private final static int BUFFER_LENGTH = 1024;

		/**
		 * 日志标记。
		 */
		private final static String LOG_TAG = "CreateTask";

		@Override
		protected void onPreExecute()
		{
			// 创建进度对话框
			this.m_ProgressDialog = new ProgressDialog(ManifestActivity.this);
			// 设置进度条样式
			this.m_ProgressDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
			// 设置标题
			this.m_ProgressDialog.setTitle(R.string.title_create_activity);
			// 设置提示信息
			this.m_ProgressDialog.setMessage(ManifestActivity.this.getString(R.string.message_create_manifest));
			// 设置允许取消
			this.m_ProgressDialog.setCancelable(true);
			// 挂接后退按钮点击事件
			this.m_ProgressDialog.setOnCancelListener(new DialogInterface.OnCancelListener()
			{
				// 处理取消按钮点击事件
				public void onCancel(DialogInterface dialog)
				{
					// 取消任务
					CreateTask.this.cancel(true);
				}
			});
			// 设置按钮标题
			this.m_ProgressDialog.setButton(ManifestActivity.this.getString(R.string.button_cancel), new DialogInterface.OnClickListener()
			{
				public void onClick(DialogInterface dialog, int which)
				{
					// 取消任务
					CreateTask.this.cancel(true);
				}
			});

			// 设置图标
			this.m_ProgressDialog.setIcon(R.drawable.icon_add);
			// 显示对话框
			this.m_ProgressDialog.show();
		}

		@Override
		protected JSONObject doInBackground(Manifest... params)
		{
			try
			{
				// 创建请求客户端
				DefaultHttpClient client = new DefaultHttpClient();

				// 获得要创建的清单
				Manifest entity = params[0];

				// 读取数据
				JSONObject result = this.createManifest(client, entity);

				// 判断是否创建成功
				if (null != result && result.getBoolean("IsSuccessed"))
				{
					// 获得清单编号
					String manifestID = result.getString("ManifestID");

					// 循环上传照片
					for (ManifestPhoto photo : ManifestActivity.this.getPhotos())
					{
						try
						{
							// 上传照片
							this.uploadManifestPhoto(client, manifestID, photo);
						}
						catch (Exception ex)
						{
							// 记录日志
							Log.e(CreateTask.LOG_TAG, ex.toString());

							// 记录同步过程中发生的异常
							this.m_InnerException = ex;
						}
					}
				}

				// 返回结果
				return result;
			}
			catch (Exception ex)
			{
				// 记录日志
				Log.e(CreateTask.LOG_TAG, ex.toString());

				// 记录同步过程中发生的异常
				this.m_InnerException = ex;

				// 返回同步失败
				return null;
			}
		}

		@Override
		protected void onProgressUpdate(String... values)
		{
			// 判断进度窗体是否已经创建
			if (null != this.m_ProgressDialog)
			{
				this.m_ProgressDialog.setMessage(values[0]);
			}
		}

		/**
		 * 同步任务后置处理器。
		 */
		@Override
		protected void onPostExecute(JSONObject result)
		{
			// 释放对话框对象
			if (null != this.m_ProgressDialog)
			{
				this.m_ProgressDialog.dismiss();
			}

			// 判断是否发生异常
			if (null != this.m_InnerException)
			{
				// 创建对话框
				AlertDialog.Builder dialog = new AlertDialog.Builder(ManifestActivity.this);

				// 设置标题
				dialog.setTitle(R.string.title_application_name);
				// 设置消息
				dialog.setMessage("送检清单创建失败，创建送检清单的过程中发生错误：\r\n" + this.m_InnerException.toString());
				// 设置不允许取消
				dialog.setCancelable(false);
				// 设置图标编号
				dialog.setIcon(R.drawable.icon_error);

				// 添加取消按钮
				dialog.setPositiveButton(R.string.button_ok, new DialogInterface.OnClickListener()
				{
					// 处理点击事件
					public void onClick(DialogInterface dialog, int which)
					{
						// 关闭对话框
						dialog.dismiss();
					}
				});

				// 显示对话框
				dialog.show();
			}
			else
			{
				try
				{
					// 判断是否登录成功
					if (!result.getBoolean("IsSuccessed"))
					{
						// 创建对话框
						AlertDialog.Builder dialog = new AlertDialog.Builder(ManifestActivity.this);

						// 设置标题
						dialog.setTitle(R.string.title_application_name);
						// 设置消息
						dialog.setMessage(result.getString("ErrorMessage"));
						// 设置不允许取消
						dialog.setCancelable(false);
						// 设置图标编号
						dialog.setIcon(R.drawable.icon_error);

						// 添加取消按钮
						dialog.setPositiveButton(R.string.button_ok, new DialogInterface.OnClickListener()
						{
							// 处理点击事件
							public void onClick(DialogInterface dialog, int which)
							{
								// 关闭对话框
								dialog.dismiss();
							}
						});

						// 显示对话框
						dialog.show();
					}
					else
					{
						// 提示信息
						Toast.makeText(ManifestActivity.this, "送检清单创建成功。", Toast.LENGTH_SHORT).show();

						// 设定返回值
						ManifestActivity.this.setResult(Activity.RESULT_OK);

						// 结束活动
						ManifestActivity.this.finish();
					}
				}
				catch (Exception ex)
				{
					// 创建对话框
					AlertDialog.Builder dialog = new AlertDialog.Builder(ManifestActivity.this);

					// 设置标题
					dialog.setTitle(R.string.title_application_name);
					// 设置消息
					dialog.setMessage("送检清单创建失败，创建送检清单的过程中发生错误：\r\n" + ex.toString());
					// 设置不允许取消
					dialog.setCancelable(false);
					// 设置图标编号
					dialog.setIcon(R.drawable.icon_error);

					// 添加取消按钮
					dialog.setPositiveButton(R.string.button_ok, new DialogInterface.OnClickListener()
					{
						// 处理点击事件
						public void onClick(DialogInterface dialog, int which)
						{
							// 关闭对话框
							dialog.dismiss();
						}
					});

					// 显示对话框
					dialog.show();
				}
			}
		}

		/**
		 * 创建送检清单。
		 */
		private JSONObject createManifest(DefaultHttpClient client, Manifest entity) throws Exception
		{
			// 获得共享存储器
			SharedPreferences settings = getSharedPreferences(getString(R.string.app_name), 0);

			// 读取服务器地址
			String url = settings.getString(SettingActivity.KEY_ADDRESS, null);

			// 判断是否以/结尾
			if (url.endsWith("/"))
			{
				url = String.format("%1$sServices/MobileService.svc/CreateManifest", url);
			}
			else
			{
				url = String.format("%1$s/Services/MobileService.svc/CreateManifest", url);
			}

			// 创建HTTP请求对象
			HttpPost request = new HttpPost(url);

			// 创建条件对象
			JSONObject condition = new JSONObject();

			// 添加条件
			condition.put("userID", LoginActivity.SESSION_ID);
			condition.put("customerID", entity.getCustomerID());
			condition.put("title", entity.getTitle());
			condition.put("memo", entity.getMemo());

			// 添加条件
			request.setEntity(new StringEntity(condition.toString(), HTTP.UTF_8));

			// 设置参数
			request.setHeader("Accept", "application/json");
			request.setHeader("Content-type", "application/json");

			// 获得请求参数
			HttpParams params = request.getParams();

			// 设置连接超时
			HttpConnectionParams.setConnectionTimeout(params, CONNECTION_TIMEOUT);
			// 设置接收超时
			HttpConnectionParams.setSoTimeout(params, SOCKET_TIMEOUT);

			// 执行请求
			HttpResponse response = client.execute(request);

			// 读取反馈内容
			String responseText = RetrieveInputStream(response.getEntity());

			// 判断是否请求成功
			if (HTTP_OK != response.getStatusLine().getStatusCode())
			{
				// 记录日志
				Log.e(LOG_TAG, responseText);

				// 抛出异常
				throw new Exception(responseText);
			}

			// 返回数据
			return new JSONObject(responseText);
		}

		/**
		 * 上传清单照片。
		 */
		private JSONObject uploadManifestPhoto(DefaultHttpClient client, String manifestID, ManifestPhoto entity) throws Exception
		{
			// 获得共享存储器
			SharedPreferences settings = getSharedPreferences(getString(R.string.app_name), 0);

			// 读取服务器地址
			String url = settings.getString(SettingActivity.KEY_ADDRESS, null);

			// 判断是否以/结尾
			if (url.endsWith("/"))
			{
				url = String.format("%1$sServices/MobileService.svc/UploadManifestPhoto", url);
			}
			else
			{
				url = String.format("%1$s/Services/MobileService.svc/UploadManifestPhoto", url);
			}

			// 创建HTTP请求对象
			HttpPost request = new HttpPost(url);

			// 创建条件对象
			JSONObject condition = new JSONObject();

			// 添加条件
			condition.put("userID", LoginActivity.SESSION_ID);
			condition.put("manifestID", manifestID);
			condition.put("name", entity.getName());
			condition.put("data", Utility.BitmapToBase64(entity.getImageFile(), 1440, 1440));

			// 添加条件
			request.setEntity(new StringEntity(condition.toString(), HTTP.UTF_8));

			// 设置参数
			request.setHeader("Accept", "application/json");
			request.setHeader("Content-type", "application/json");

			// 获得请求参数
			HttpParams params = request.getParams();

			// 设置连接超时
			HttpConnectionParams.setConnectionTimeout(params, CONNECTION_TIMEOUT);
			// 设置接收超时
			HttpConnectionParams.setSoTimeout(params, SOCKET_TIMEOUT);

			// 执行请求
			HttpResponse response = client.execute(request);

			// 读取反馈内容
			String responseText = RetrieveInputStream(response.getEntity());

			// 判断是否请求成功
			if (HTTP_OK != response.getStatusLine().getStatusCode())
			{
				// 记录日志
				Log.e(LOG_TAG, responseText);

				// 抛出异常
				throw new Exception(responseText);
			}

			// 返回数据
			return new JSONObject(responseText);
		}

		/**
		 * 从给定的HTTP实体中获得反馈内容。
		 */
		private String RetrieveInputStream(HttpEntity entity) throws Exception
		{
			// 获得内容长度
			int length = (int) entity.getContentLength();

			// 判断长度是否小于0
			if (length < 0)
			{
				// 如果小于0，则默认为10K
				length = 10 * BUFFER_LENGTH;
			}

			// 用于保存返回字符串内容
			StringBuffer result = new StringBuffer(length);

			// 创建输入流读取器
			InputStreamReader reader = new InputStreamReader(entity.getContent(), HTTP.UTF_8);

			// 用于保存缓存数据
			char buffer[] = new char[BUFFER_LENGTH];

			// 用于记录读取的数据长度
			int count = 0;

			// 循环读取数据
			do
			{
				// 读取数据
				count = reader.read(buffer, 0, BUFFER_LENGTH);

				// 判断是否读取了数据
				if (count > 0)
				{
					// 添加数据
					result.append(buffer, 0, count);
				}
			}
			while (count > 0);

			// 返回结果
			return result.toString();
		}
	}
}
